return;
/* get the state value */
- err = xenbus_scanf(dir, "availability", "%s", state);
+ err = xenbus_scanf(NULL, dir, "availability", "%s", state);
if (err != 1) {
printk(KERN_ERR
{
static DECLARE_WORK(shutdown_work, __shutdown_handler, NULL);
char *str;
+ struct xenbus_transaction *xbt;
int err;
again:
- err = xenbus_transaction_start();
- if (err)
+ xbt = xenbus_transaction_start();
+ if (IS_ERR(xbt))
return;
- str = (char *)xenbus_read("control", "shutdown", NULL);
+ str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
/* Ignore read errors and empty reads. */
if (XENBUS_IS_ERR_READ(str)) {
- xenbus_transaction_end(1);
+ xenbus_transaction_end(xbt, 1);
return;
}
- xenbus_write("control", "shutdown", "");
+ xenbus_write(xbt, "control", "shutdown", "");
- err = xenbus_transaction_end(0);
+ err = xenbus_transaction_end(xbt, 0);
if (err == -EAGAIN) {
kfree(str);
goto again;
unsigned int len)
{
char sysrq_key = '\0';
+ struct xenbus_transaction *xbt;
int err;
again:
- err = xenbus_transaction_start();
- if (err)
+ xbt = xenbus_transaction_start();
+ if (IS_ERR(xbt))
return;
- if (!xenbus_scanf("control", "sysrq", "%c", &sysrq_key)) {
+ if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
printk(KERN_ERR "Unable to read sysrq code in "
"control/sysrq\n");
- xenbus_transaction_end(1);
+ xenbus_transaction_end(xbt, 1);
return;
}
if (sysrq_key != '\0')
- xenbus_printf("control", "sysrq", "%c", '\0');
+ xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
- err = xenbus_transaction_end(0);
+ err = xenbus_transaction_end(xbt, 0);
if (err == -EAGAIN)
goto again;
unsigned long long new_target;
int err;
- err = xenbus_scanf("memory", "target", "%llu", &new_target);
+ err = xenbus_scanf(NULL, "memory", "target", "%llu", &new_target);
if (err != 1) {
printk(KERN_ERR "Unable to read memory/target\n");
return;
unsigned long ring_ref;
unsigned int evtchn;
int err;
+ struct xenbus_transaction *xbt;
struct backend_info *be
= container_of(watch, struct backend_info, watch);
/* If other end is gone, delete ourself. */
- if (vec && !xenbus_exists(be->frontpath, "")) {
+ if (vec && !xenbus_exists(NULL, be->frontpath, "")) {
device_unregister(&be->dev->dev);
return;
}
if (be->blkif == NULL || be->blkif->status == CONNECTED)
return;
- err = xenbus_gather(be->frontpath, "ring-ref", "%lu", &ring_ref,
+ err = xenbus_gather(NULL, be->frontpath, "ring-ref", "%lu", &ring_ref,
"event-channel", "%u", &evtchn, NULL);
if (err) {
xenbus_dev_error(be->dev, err,
/* Map the shared frame, irq etc. */
err = blkif_map(be->blkif, ring_ref, evtchn);
if (err) {
- xenbus_dev_error(be->dev, err, "mapping ring-ref %lu port %u",
+ xenbus_dev_error(be->dev, err,
+ "mapping ring-ref %lu port %u",
ring_ref, evtchn);
return;
}
again:
/* Supply the information about the device the frontend needs */
- err = xenbus_transaction_start();
- if (err) {
+ xbt = xenbus_transaction_start();
+ if (IS_ERR(xbt)) {
xenbus_dev_error(be->dev, err, "starting transaction");
return;
}
- err = xenbus_printf(be->dev->nodename, "sectors", "%lu",
+ err = xenbus_printf(xbt, be->dev->nodename, "sectors", "%lu",
vbd_size(&be->blkif->vbd));
if (err) {
xenbus_dev_error(be->dev, err, "writing %s/sectors",
}
/* FIXME: use a typename instead */
- err = xenbus_printf(be->dev->nodename, "info", "%u",
+ err = xenbus_printf(xbt, be->dev->nodename, "info", "%u",
vbd_info(&be->blkif->vbd));
if (err) {
xenbus_dev_error(be->dev, err, "writing %s/info",
be->dev->nodename);
goto abort;
}
- err = xenbus_printf(be->dev->nodename, "sector-size", "%lu",
+ err = xenbus_printf(xbt, be->dev->nodename, "sector-size", "%lu",
vbd_secsize(&be->blkif->vbd));
if (err) {
xenbus_dev_error(be->dev, err, "writing %s/sector-size",
goto abort;
}
- err = xenbus_transaction_end(0);
+ err = xenbus_transaction_end(xbt, 0);
if (err == -EAGAIN)
goto again;
if (err) {
return;
abort:
- xenbus_transaction_end(1);
+ xenbus_transaction_end(xbt, 1);
}
/*
= container_of(watch, struct backend_info, backend_watch);
struct xenbus_device *dev = be->dev;
- err = xenbus_scanf(dev->nodename, "physical-device", "%li", &pdev);
+ err = xenbus_scanf(NULL, dev->nodename,
+ "physical-device", "%li", &pdev);
if (XENBUS_EXIST_ERR(err))
return;
if (err < 0) {
be->pdev = pdev;
/* If there's a read-only node, we're read only. */
- p = xenbus_read(dev->nodename, "read-only", NULL);
+ p = xenbus_read(NULL, dev->nodename, "read-only", NULL);
if (!IS_ERR(p)) {
be->readonly = 1;
kfree(p);
if (IS_ERR(be->blkif)) {
err = PTR_ERR(be->blkif);
be->blkif = NULL;
- xenbus_dev_error(dev, err, "creating block interface");
+ xenbus_dev_error(dev, err,
+ "creating block interface");
return;
}
if (err) {
blkif_put(be->blkif);
be->blkif = NULL;
- xenbus_dev_error(dev, err, "creating vbd structure");
+ xenbus_dev_error(dev, err,
+ "creating vbd structure");
return;
}
be = kmalloc(sizeof(*be), GFP_KERNEL);
if (!be) {
- xenbus_dev_error(dev, -ENOMEM, "allocating backend structure");
+ xenbus_dev_error(dev, -ENOMEM,
+ "allocating backend structure");
return -ENOMEM;
}
memset(be, 0, sizeof(*be));
frontend = NULL;
- err = xenbus_gather(dev->nodename,
+ err = xenbus_gather(NULL, dev->nodename,
"frontend-id", "%li", &be->frontend_id,
"frontend", NULL, &frontend,
NULL);
dev->nodename);
goto free_be;
}
- if (strlen(frontend) == 0 || !xenbus_exists(frontend, "")) {
+ if (strlen(frontend) == 0 || !xenbus_exists(NULL, frontend, "")) {
/* If we can't get a frontend path and a frontend-id,
* then our bus-id is no longer valid and we need to
* destroy the backend device.
err = register_xenbus_watch(&be->backend_watch);
if (err) {
be->backend_watch.node = NULL;
- xenbus_dev_error(dev, err, "adding backend watch on %s",
+ xenbus_dev_error(dev, err,
+ "adding backend watch on %s",
dev->nodename);
goto free_be;
}
if (info->connected == BLKIF_STATE_CONNECTED)
return;
- err = xenbus_gather(watch->node,
+ err = xenbus_gather(NULL, watch->node,
"sectors", "%lu", §ors,
"info", "%u", &binfo,
"sector-size", "%lu", §or_size,
{
char *backend;
const char *message;
+ struct xenbus_transaction *xbt;
int err;
backend = NULL;
- err = xenbus_gather(dev->nodename,
+ err = xenbus_gather(NULL, dev->nodename,
"backend-id", "%i", &info->backend_id,
"backend", NULL, &backend,
NULL);
}
again:
- err = xenbus_transaction_start();
- if (err) {
+ xbt = xenbus_transaction_start();
+ if (IS_ERR(xbt)) {
xenbus_dev_error(dev, err, "starting transaction");
goto destroy_blkring;
}
- err = xenbus_printf(dev->nodename, "ring-ref","%u", info->ring_ref);
+ err = xenbus_printf(xbt, dev->nodename,
+ "ring-ref","%u", info->ring_ref);
if (err) {
message = "writing ring-ref";
goto abort_transaction;
}
- err = xenbus_printf(dev->nodename,
+ err = xenbus_printf(xbt, dev->nodename,
"event-channel", "%u", info->evtchn);
if (err) {
message = "writing event-channel";
goto abort_transaction;
}
- err = xenbus_transaction_end(0);
+ err = xenbus_transaction_end(xbt, 0);
if (err) {
if (err == -EAGAIN)
goto again;
return 0;
abort_transaction:
- xenbus_transaction_end(1);
- /* Have to do this *outside* transaction. */
+ xenbus_transaction_end(xbt, 1);
xenbus_dev_error(dev, err, "%s", message);
destroy_blkring:
blkif_free(info);
struct blkfront_info *info;
/* FIXME: Use dynamic device id if this is not set. */
- err = xenbus_scanf(dev->nodename, "virtual-device", "%i", &vdevice);
+ err = xenbus_scanf(NULL, dev->nodename,
+ "virtual-device", "%i", &vdevice);
if (XENBUS_EXIST_ERR(err))
return err;
if (err < 0) {
int i;
/* If other end is gone, delete ourself. */
- if (vec && !xenbus_exists(be->frontpath, "")) {
- xenbus_rm(be->dev->nodename, "");
+ if (vec && !xenbus_exists(NULL, be->frontpath, "")) {
+ xenbus_rm(NULL, be->dev->nodename, "");
device_unregister(&be->dev->dev);
return;
}
if (be->netif == NULL || be->netif->status == CONNECTED)
return;
- mac = xenbus_read(be->frontpath, "mac", NULL);
+ mac = xenbus_read(NULL, be->frontpath, "mac", NULL);
if (IS_ERR(mac)) {
err = PTR_ERR(mac);
xenbus_dev_error(be->dev, err, "reading %s/mac",
}
kfree(mac);
- err = xenbus_gather(be->frontpath, "tx-ring-ref", "%lu", &tx_ring_ref,
+ err = xenbus_gather(NULL, be->frontpath,
+ "tx-ring-ref", "%lu", &tx_ring_ref,
"rx-ring-ref", "%lu", &rx_ring_ref,
"event-channel", "%u", &evtchn, NULL);
if (err) {
struct xenbus_device *dev = be->dev;
u8 be_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
- err = xenbus_scanf(dev->nodename, "handle", "%li", &handle);
+ err = xenbus_scanf(NULL, dev->nodename, "handle", "%li", &handle);
if (XENBUS_EXIST_ERR(err))
return;
if (err < 0) {
key = env_vars;
while (*key != NULL) {
- val = xenbus_read(xdev->nodename, *key, NULL);
+ val = xenbus_read(NULL, xdev->nodename, *key, NULL);
if (!IS_ERR(val)) {
char buf[strlen(*key) + 4];
sprintf(buf, "%s=%%s", *key);
memset(be, 0, sizeof(*be));
frontend = NULL;
- err = xenbus_gather(dev->nodename,
+ err = xenbus_gather(NULL, dev->nodename,
"frontend-id", "%li", &be->frontend_id,
"frontend", NULL, &frontend,
NULL);
dev->nodename);
goto free_be;
}
- if (strlen(frontend) == 0 || !xenbus_exists(frontend, "")) {
+ if (strlen(frontend) == 0 || !xenbus_exists(NULL, frontend, "")) {
/* If we can't get a frontend path and a frontend-id,
* then our bus-id is no longer valid and we need to
* destroy the backend device.
{
char *backend, *mac, *e, *s;
const char *message;
+ struct xenbus_transaction *xbt;
int err, i;
backend = NULL;
- err = xenbus_gather(dev->nodename,
+ err = xenbus_gather(NULL, dev->nodename,
"backend-id", "%i", &info->backend_id,
"backend", NULL, &backend,
NULL);
goto out;
}
- mac = xenbus_read(dev->nodename, "mac", NULL);
+ mac = xenbus_read(NULL, dev->nodename, "mac", NULL);
if (IS_ERR(mac)) {
err = PTR_ERR(mac);
xenbus_dev_error(dev, err, "reading %s/mac",
}
again:
- err = xenbus_transaction_start();
- if (err) {
+ xbt = xenbus_transaction_start();
+ if (IS_ERR(xbt)) {
xenbus_dev_error(dev, err, "starting transaction");
goto destroy_ring;
}
- err = xenbus_printf(dev->nodename, "tx-ring-ref","%u",
+ err = xenbus_printf(xbt, dev->nodename, "tx-ring-ref","%u",
info->tx_ring_ref);
if (err) {
message = "writing tx ring-ref";
goto abort_transaction;
}
- err = xenbus_printf(dev->nodename, "rx-ring-ref","%u",
+ err = xenbus_printf(xbt, dev->nodename, "rx-ring-ref","%u",
info->rx_ring_ref);
if (err) {
message = "writing rx ring-ref";
goto abort_transaction;
}
- err = xenbus_printf(dev->nodename,
+ err = xenbus_printf(xbt, dev->nodename,
"event-channel", "%u", info->evtchn);
if (err) {
message = "writing event-channel";
goto abort_transaction;
}
- err = xenbus_transaction_end(0);
+ err = xenbus_transaction_end(xbt, 0);
if (err) {
if (err == -EAGAIN)
goto again;
return 0;
abort_transaction:
- xenbus_transaction_end(1);
- /* Have to do this *outside* transaction. */
+ xenbus_transaction_end(xbt, 1);
xenbus_dev_error(dev, err, "%s", message);
destroy_ring:
shutdown_device(info);
struct netfront_info *info;
unsigned int handle;
- err = xenbus_scanf(dev->nodename, "handle", "%u", &handle);
+ err = xenbus_scanf(NULL, dev->nodename, "handle", "%u", &handle);
if (XENBUS_EXIST_ERR(err))
return err;
if (err < 0) {
unsigned int evtchn;
unsigned long ready = 1;
int err;
+ struct xenbus_transaction *xbt;
struct backend_info *be
= container_of(watch, struct backend_info, watch);
/* If other end is gone, delete ourself. */
- if (vec && !xenbus_exists(be->frontpath, "")) {
- xenbus_rm(be->dev->nodename, "");
+ if (vec && !xenbus_exists(NULL, be->frontpath, "")) {
+ xenbus_rm(NULL, be->dev->nodename, "");
device_unregister(&be->dev->dev);
return;
}
if (be->tpmif == NULL || be->tpmif->status == CONNECTED)
return;
- err = xenbus_gather(be->frontpath,
+ err = xenbus_gather(NULL, be->frontpath,
"ring-ref", "%lu", &ringref,
"event-channel", "%u", &evtchn, NULL);
if (err) {
* unless something bad happens
*/
again:
- err = xenbus_transaction_start();
- if (err) {
+ xbt = xenbus_transaction_start();
+ if (IS_ERR(xbt)) {
xenbus_dev_error(be->dev, err, "starting transaction");
return;
}
- err = xenbus_printf(be->dev->nodename,
+ err = xenbus_printf(xbt, be->dev->nodename,
"ready", "%lu", ready);
if (err) {
xenbus_dev_error(be->dev, err, "writing 'ready'");
goto abort;
}
- err = xenbus_transaction_end(0);
+ err = xenbus_transaction_end(xbt, 0);
if (err == -EAGAIN)
goto again;
if (err) {
xenbus_dev_ok(be->dev);
return;
abort:
- xenbus_transaction_end(1);
+ xenbus_transaction_end(xbt, 1);
}
= container_of(watch, struct backend_info, backend_watch);
struct xenbus_device *dev = be->dev;
- err = xenbus_scanf(dev->nodename, "instance", "%li", &instance);
+ err = xenbus_scanf(NULL, dev->nodename, "instance", "%li", &instance);
if (XENBUS_EXIST_ERR(err))
return;
if (err < 0) {
memset(be, 0, sizeof(*be));
frontend = NULL;
- err = xenbus_gather(dev->nodename,
+ err = xenbus_gather(NULL, dev->nodename,
"frontend-id", "%li", &be->frontend_id,
"frontend", NULL, &frontend,
NULL);
dev->nodename);
goto free_be;
}
- if (strlen(frontend) == 0 || !xenbus_exists(frontend, "")) {
+ if (strlen(frontend) == 0 || !xenbus_exists(NULL, frontend, "")) {
/* If we can't get a frontend path and a frontend-id,
* then our bus-id is no longer valid and we need to
* destroy the backend device.
if (tp->connected)
return;
- err = xenbus_gather(watch->node,
+ err = xenbus_gather(NULL, watch->node,
"ready", "%lu", &ready,
NULL);
if (err) {
const char *message;
int err;
int backend_id;
+ struct xenbus_transaction *xbt;
backend = NULL;
- err = xenbus_gather(dev->nodename,
+ err = xenbus_gather(NULL, dev->nodename,
"backend-id", "%i", &backend_id,
"backend", NULL, &backend,
NULL);
}
again:
- err = xenbus_transaction_start();
- if (err) {
+ xbt = xenbus_transaction_start();
+ if (IS_ERR(xbt)) {
xenbus_dev_error(dev, err, "starting transaction");
goto destroy_tpmring;
}
- err = xenbus_printf(dev->nodename,
+ err = xenbus_printf(xbt, dev->nodename,
"ring-ref","%u", info->ring_ref);
if (err) {
message = "writing ring-ref";
goto abort_transaction;
}
- err = xenbus_printf(dev->nodename,
+ err = xenbus_printf(xbt, dev->nodename,
"event-channel", "%u", my_private.evtchn);
if (err) {
message = "writing event-channel";
goto abort_transaction;
}
- err = xenbus_transaction_end(0);
+ err = xenbus_transaction_end(xbt, 0);
if (err == -EAGAIN)
goto again;
if (err) {
return 0;
abort_transaction:
- xenbus_transaction_end(1);
- /* Have to do this *outside* transaction. */
+ xenbus_transaction_end(xbt, 1);
xenbus_dev_error(dev, err, "%s", message);
destroy_tpmring:
destroy_tpmring(info, &my_private);
struct tpmfront_info *info;
int handle;
- err = xenbus_scanf(dev->nodename,
+ err = xenbus_scanf(NULL, dev->nodename,
"handle", "%i", &handle);
if (XENBUS_EXIST_ERR(err))
return err;
struct xenbus_dev_data *u = filp->private_data;
if (u->in_transaction)
- xenbus_transaction_end(1);
+ xenbus_transaction_end((struct xenbus_transaction *)1, 1);
kfree(u);
devid = strrchr(nodename, '/') + 1;
- err = xenbus_gather(nodename, "frontend-id", "%i", &domid,
+ err = xenbus_gather(NULL, nodename, "frontend-id", "%i", &domid,
"frontend", NULL, &frontend,
NULL);
if (err)
if (strlen(frontend) == 0)
err = -ERANGE;
- if (!err && !xenbus_exists(frontend, ""))
+ if (!err && !xenbus_exists(NULL, frontend, ""))
err = -ENOENT;
if (err) {
if (!nodename)
return -ENOMEM;
- dir = xenbus_directory(nodename, "", &dir_n);
+ dir = xenbus_directory(NULL, nodename, "", &dir_n);
if (IS_ERR(dir)) {
kfree(nodename);
return PTR_ERR(dir);
unsigned int dir_n = 0;
int i;
- dir = xenbus_directory(bus->root, type, &dir_n);
+ dir = xenbus_directory(NULL, bus->root, type, &dir_n);
if (IS_ERR(dir))
return PTR_ERR(dir);
char **dir;
unsigned int i, dir_n;
- dir = xenbus_directory(bus->root, "", &dir_n);
+ dir = xenbus_directory(NULL, bus->root, "", &dir_n);
if (IS_ERR(dir))
return PTR_ERR(dir);
if (char_count(node, '/') < 2)
return;
- exists = xenbus_exists(node, "");
+ exists = xenbus_exists(NULL, node, "");
if (!exists) {
xenbus_cleanup_devices(node, &bus->bus);
return;
return ret;
}
-char **xenbus_directory(const char *dir, const char *node, unsigned int *num)
+char **xenbus_directory(struct xenbus_transaction *t,
+ const char *dir, const char *node, unsigned int *num)
{
char *strings;
unsigned int len;
EXPORT_SYMBOL(xenbus_directory);
/* Check if a path exists. Return 1 if it does. */
-int xenbus_exists(const char *dir, const char *node)
+int xenbus_exists(struct xenbus_transaction *t,
+ const char *dir, const char *node)
{
char **d;
int dir_n;
- d = xenbus_directory(dir, node, &dir_n);
+ d = xenbus_directory(t, dir, node, &dir_n);
if (IS_ERR(d))
return 0;
kfree(d);
* Returns a kmalloced value: call free() on it after use.
* len indicates length in bytes.
*/
-void *xenbus_read(const char *dir, const char *node, unsigned int *len)
+void *xenbus_read(struct xenbus_transaction *t,
+ const char *dir, const char *node, unsigned int *len)
{
return xs_single(XS_READ, join(dir, node), len);
}
/* Write the value of a single file.
* Returns -err on failure.
*/
-int xenbus_write(const char *dir, const char *node, const char *string)
+int xenbus_write(struct xenbus_transaction *t,
+ const char *dir, const char *node, const char *string)
{
const char *path;
struct kvec iovec[2];
EXPORT_SYMBOL(xenbus_write);
/* Create a new directory. */
-int xenbus_mkdir(const char *dir, const char *node)
+int xenbus_mkdir(struct xenbus_transaction *t,
+ const char *dir, const char *node)
{
return xs_error(xs_single(XS_MKDIR, join(dir, node), NULL));
}
EXPORT_SYMBOL(xenbus_mkdir);
/* Destroy a file or directory (directories must be empty). */
-int xenbus_rm(const char *dir, const char *node)
+int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node)
{
return xs_error(xs_single(XS_RM, join(dir, node), NULL));
}
/* Start a transaction: changes by others will not be seen during this
* transaction, and changes will not be visible to others until end.
- * You can only have one transaction at any time.
*/
-int xenbus_transaction_start(void)
+struct xenbus_transaction *xenbus_transaction_start(void)
{
int err;
up(&xs_state.transaction_mutex);
}
- return err;
+ return err ? ERR_PTR(err) : (struct xenbus_transaction *)1;
}
EXPORT_SYMBOL(xenbus_transaction_start);
/* End a transaction.
* If abandon is true, transaction is discarded instead of committed.
*/
-int xenbus_transaction_end(int abort)
+int xenbus_transaction_end(struct xenbus_transaction *t, int abort)
{
char abortstr[2];
int err;
+ BUG_ON(t == NULL);
+
if (abort)
strcpy(abortstr, "F");
else
EXPORT_SYMBOL(xenbus_transaction_end);
/* Single read and scanf: returns -errno or num scanned. */
-int xenbus_scanf(const char *dir, const char *node, const char *fmt, ...)
+int xenbus_scanf(struct xenbus_transaction *t,
+ const char *dir, const char *node, const char *fmt, ...)
{
va_list ap;
int ret;
char *val;
- val = xenbus_read(dir, node, NULL);
+ val = xenbus_read(t, dir, node, NULL);
if (IS_ERR(val))
return PTR_ERR(val);
EXPORT_SYMBOL(xenbus_scanf);
/* Single printf and write: returns -errno or 0. */
-int xenbus_printf(const char *dir, const char *node, const char *fmt, ...)
+int xenbus_printf(struct xenbus_transaction *t,
+ const char *dir, const char *node, const char *fmt, ...)
{
va_list ap;
int ret;
va_end(ap);
BUG_ON(ret > PRINTF_BUFFER_SIZE-1);
- ret = xenbus_write(dir, node, printf_buffer);
+ ret = xenbus_write(t, dir, node, printf_buffer);
kfree(printf_buffer);
BUG_ON(len + ret > PRINTF_BUFFER_SIZE-1);
dev->has_error = 1;
- if (xenbus_write(dev->nodename, "error", printf_buffer) != 0)
+ if (xenbus_write(NULL, dev->nodename, "error", printf_buffer) != 0)
goto fail;
kfree(printf_buffer);
void xenbus_dev_ok(struct xenbus_device *dev)
{
if (dev->has_error) {
- if (xenbus_rm(dev->nodename, "error") != 0)
+ if (xenbus_rm(NULL, dev->nodename, "error") != 0)
printk("xenbus: failed to clear error node for %s\n",
dev->nodename);
else
EXPORT_SYMBOL(xenbus_dev_ok);
/* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
-int xenbus_gather(const char *dir, ...)
+int xenbus_gather(struct xenbus_transaction *t, const char *dir, ...)
{
va_list ap;
const char *name;
void *result = va_arg(ap, void *);
char *p;
- p = xenbus_read(dir, name, NULL);
+ p = xenbus_read(t, dir, name, NULL);
if (IS_ERR(p)) {
ret = PTR_ERR(p);
break;
int xenbus_register_backend(struct xenbus_driver *drv);
void xenbus_unregister_driver(struct xenbus_driver *drv);
-char **xenbus_directory(const char *dir, const char *node, unsigned int *num);
-void *xenbus_read(const char *dir, const char *node, unsigned int *len);
-int xenbus_write(const char *dir, const char *node, const char *string);
-int xenbus_mkdir(const char *dir, const char *node);
-int xenbus_exists(const char *dir, const char *node);
-int xenbus_rm(const char *dir, const char *node);
-int xenbus_transaction_start(void);
-int xenbus_transaction_end(int abort);
+struct xenbus_transaction;
+
+char **xenbus_directory(struct xenbus_transaction *t,
+ const char *dir, const char *node, unsigned int *num);
+void *xenbus_read(struct xenbus_transaction *t,
+ const char *dir, const char *node, unsigned int *len);
+int xenbus_write(struct xenbus_transaction *t,
+ const char *dir, const char *node, const char *string);
+int xenbus_mkdir(struct xenbus_transaction *t,
+ const char *dir, const char *node);
+int xenbus_exists(struct xenbus_transaction *t,
+ const char *dir, const char *node);
+int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node);
+struct xenbus_transaction *xenbus_transaction_start(void);
+int xenbus_transaction_end(struct xenbus_transaction *t, int abort);
/* Single read and scanf: returns -errno or num scanned if > 0. */
-int xenbus_scanf(const char *dir, const char *node, const char *fmt, ...)
- __attribute__((format(scanf, 3, 4)));
+int xenbus_scanf(struct xenbus_transaction *t,
+ const char *dir, const char *node, const char *fmt, ...)
+ __attribute__((format(scanf, 4, 5)));
/* Single printf and write: returns -errno or 0. */
-int xenbus_printf(const char *dir, const char *node, const char *fmt, ...)
- __attribute__((format(printf, 3, 4)));
+int xenbus_printf(struct xenbus_transaction *t,
+ const char *dir, const char *node, const char *fmt, ...)
+ __attribute__((format(printf, 4, 5)));
/* Generic read function: NULL-terminated triples of name,
* sprintf-style type string, and pointer. Returns 0 or errno.*/
-int xenbus_gather(const char *dir, ...);
+int xenbus_gather(struct xenbus_transaction *t, const char *dir, ...);
/* Report a (negative) errno into the store, with explanation. */
void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt,...);
if (path == NULL)
err(ENOMEM, "realloc");
strcat(path, "/console/tty");
- str_pty = xs_read(xs, path, &len);
+ str_pty = xs_read(xs, NULL, path, &len);
/* FIXME consoled currently does not assume domain-0 doesn't have a
console which is good when we break domain-0 up. To keep us
struct timeval tv = { 0, 500 };
select(0, NULL, NULL, NULL, &tv); /* pause briefly */
- str_pty = xs_read(xs, path, &len);
+ str_pty = xs_read(xs, NULL, path, &len);
}
if (str_pty == NULL) {
success = asprintf(&path, "%s/tty", dom->conspath) != -1;
if (!success)
goto out;
- success = xs_write(xs, path, slave, strlen(slave));
+ success = xs_write(xs, NULL, path, slave, strlen(slave));
free(path);
if (!success)
goto out;
success = asprintf(&path, "%s/limit", dom->conspath) != -1;
if (!success)
goto out;
- data = xs_read(xs, path, &len);
+ data = xs_read(xs, NULL, path, &len);
if (data) {
dom->buffer.max_capacity = strtoul(data, 0, 0);
free(data);
char *p;
asprintf(&path, "%s/%s", dir, name);
- p = xs_read(xs, path, NULL);
+ p = xs_read(xs, NULL, path, NULL);
free(path);
if (p == NULL) {
ret = ENOENT;
static PyObject *xspy_read(PyObject *self, PyObject *args, PyObject *kwds)
{
- static char *kwd_spec[] = { "path", NULL };
- static char *arg_spec = "s|";
+ static char *kwd_spec[] = { "transaction", "path", NULL };
+ static char *arg_spec = "ss";
char *path = NULL;
struct xs_handle *xh = xshandle(self);
unsigned int xsval_n = 0;
PyObject *val = NULL;
+ struct xs_transaction_handle *th;
+ char *thstr;
+
if (!xh)
goto exit;
if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec,
- &path))
+ &thstr, &path))
goto exit;
+
+ th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+
Py_BEGIN_ALLOW_THREADS
- xsval = xs_read(xh, path, &xsval_n);
+ xsval = xs_read(xh, th, path, &xsval_n);
Py_END_ALLOW_THREADS
if (!xsval) {
if (errno == ENOENT) {
static PyObject *xspy_write(PyObject *self, PyObject *args, PyObject *kwds)
{
- static char *kwd_spec[] = { "path", "data", NULL };
- static char *arg_spec = "ss#";
+ static char *kwd_spec[] = { "transaction", "path", "data", NULL };
+ static char *arg_spec = "sss#";
char *path = NULL;
char *data = NULL;
int data_n = 0;
PyObject *val = NULL;
int xsval = 0;
+ struct xs_transaction_handle *th;
+ char *thstr;
+
if (!xh)
goto exit;
if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec,
- &path, &data, &data_n))
+ &thstr, &path, &data, &data_n))
goto exit;
+
+ th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+
Py_BEGIN_ALLOW_THREADS
- xsval = xs_write(xh, path, data, data_n);
+ xsval = xs_write(xh, th, path, data, data_n);
Py_END_ALLOW_THREADS
if (!xsval) {
PyErr_SetFromErrno(PyExc_RuntimeError);
static PyObject *xspy_ls(PyObject *self, PyObject *args, PyObject *kwds)
{
- static char *kwd_spec[] = { "path", NULL };
- static char *arg_spec = "s|";
+ static char *kwd_spec[] = { "transaction", "path", NULL };
+ static char *arg_spec = "ss";
char *path = NULL;
struct xs_handle *xh = xshandle(self);
unsigned int xsval_n = 0;
int i;
+ struct xs_transaction_handle *th;
+ char *thstr;
+
if (!xh)
goto exit;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec, &path))
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec,
+ &thstr, &path))
goto exit;
+
+
+ th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+
Py_BEGIN_ALLOW_THREADS
- xsval = xs_directory(xh, path, &xsval_n);
+ xsval = xs_directory(xh, th, path, &xsval_n);
Py_END_ALLOW_THREADS
if (!xsval) {
if (errno == ENOENT) {
static PyObject *xspy_mkdir(PyObject *self, PyObject *args, PyObject *kwds)
{
- static char *kwd_spec[] = { "path", NULL };
- static char *arg_spec = "s|";
+ static char *kwd_spec[] = { "transaction", "path", NULL };
+ static char *arg_spec = "ss";
char *path = NULL;
struct xs_handle *xh = xshandle(self);
PyObject *val = NULL;
int xsval = 0;
+ struct xs_transaction_handle *th;
+ char *thstr;
+
if (!xh)
goto exit;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec, &path))
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec,
+ &thstr, &path))
goto exit;
+
+ th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+
Py_BEGIN_ALLOW_THREADS
- xsval = xs_mkdir(xh, path);
+ xsval = xs_mkdir(xh, th, path);
Py_END_ALLOW_THREADS
if (!xsval) {
PyErr_SetFromErrno(PyExc_RuntimeError);
static PyObject *xspy_rm(PyObject *self, PyObject *args, PyObject *kwds)
{
- static char *kwd_spec[] = { "path", NULL };
- static char *arg_spec = "s|";
+ static char *kwd_spec[] = { "transaction", "path", NULL };
+ static char *arg_spec = "ss";
char *path = NULL;
struct xs_handle *xh = xshandle(self);
PyObject *val = NULL;
int xsval = 0;
+ struct xs_transaction_handle *th;
+ char *thstr;
+
if (!xh)
goto exit;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec, &path))
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec,
+ &thstr, &path))
goto exit;
+
+ th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+
Py_BEGIN_ALLOW_THREADS
- xsval = xs_rm(xh, path);
+ xsval = xs_rm(xh, th, path);
Py_END_ALLOW_THREADS
if (!xsval && errno != ENOENT) {
PyErr_SetFromErrno(PyExc_RuntimeError);
static PyObject *xspy_get_permissions(PyObject *self, PyObject *args,
PyObject *kwds)
{
- static char *kwd_spec[] = { "path", NULL };
- static char *arg_spec = "s|";
+ static char *kwd_spec[] = { "transaction", "path", NULL };
+ static char *arg_spec = "ss";
char *path = NULL;
struct xs_handle *xh = xshandle(self);
unsigned int perms_n = 0;
int i;
+ struct xs_transaction_handle *th;
+ char *thstr;
+
if (!xh)
goto exit;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec, &path))
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec,
+ &thstr, &path))
goto exit;
+
+ th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+
Py_BEGIN_ALLOW_THREADS
- perms = xs_get_permissions(xh, path, &perms_n);
+ perms = xs_get_permissions(xh, th, path, &perms_n);
Py_END_ALLOW_THREADS
if (!perms) {
PyErr_SetFromErrno(PyExc_RuntimeError);
static PyObject *xspy_set_permissions(PyObject *self, PyObject *args,
PyObject *kwds)
{
- static char *kwd_spec[] = { "path", "perms", NULL };
- static char *arg_spec = "sO";
+ static char *kwd_spec[] = { "transaction", "path", "perms", NULL };
+ static char *arg_spec = "ssO";
char *path = NULL;
PyObject *perms = NULL;
static char *perm_names[] = { "dom", "read", "write", NULL };
PyObject *tuple0 = NULL;
PyObject *val = NULL;
+ struct xs_transaction_handle *th;
+ char *thstr;
+
if (!xh)
goto exit;
if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec,
- &path, &perms))
+ &thstr, &path, &perms))
goto exit;
+
+ th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+
if (!PyList_Check(perms)) {
PyErr_SetString(PyExc_RuntimeError, "perms must be a list");
goto exit;
xsperms[i].perms |= XS_PERM_WRITE;
}
Py_BEGIN_ALLOW_THREADS
- xsval = xs_set_permissions(xh, path, xsperms, xsperms_n);
+ xsval = xs_set_permissions(xh, th, path, xsperms, xsperms_n);
Py_END_ALLOW_THREADS
if (!xsval) {
PyErr_SetFromErrno(PyExc_RuntimeError);
#define xspy_transaction_start_doc "\n" \
"Start a transaction.\n" \
- "Only one transaction can be active at a time.\n" \
"\n" \
- "Returns None on success.\n" \
+ "Returns transaction handle on success.\n" \
"Raises RuntimeError on error.\n" \
"\n"
struct xs_handle *xh = xshandle(self);
PyObject *val = NULL;
- int xsval = 0;
+ struct xs_transaction_handle *th;
+ char thstr[20];
if (!xh)
goto exit;
if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec, &path))
goto exit;
Py_BEGIN_ALLOW_THREADS
- xsval = xs_transaction_start(xh);
+ th = xs_transaction_start(xh);
Py_END_ALLOW_THREADS
- if (!xsval) {
+ if (th == NULL) {
PyErr_SetFromErrno(PyExc_RuntimeError);
goto exit;
}
- Py_INCREF(Py_None);
- val = Py_None;
+
+ sprintf(thstr, "%lX", (unsigned long)th);
+ val = PyString_FromString(thstr);
exit:
return val;
}
static PyObject *xspy_transaction_end(PyObject *self, PyObject *args,
PyObject *kwds)
{
- static char *kwd_spec[] = { "abort", NULL };
- static char *arg_spec = "|i";
+ static char *kwd_spec[] = { "transaction", "abort", NULL };
+ static char *arg_spec = "s|i";
int abort = 0;
struct xs_handle *xh = xshandle(self);
PyObject *val = NULL;
int xsval = 0;
+ struct xs_transaction_handle *th;
+ char *thstr;
+
if (!xh)
goto exit;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec, &abort))
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec,
+ &thstr, &abort))
goto exit;
+
+ th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+
Py_BEGIN_ALLOW_THREADS
- xsval = xs_transaction_end(xh, abort);
+ xsval = xs_transaction_end(xh, th, abort);
Py_END_ALLOW_THREADS
if (!xsval) {
if (errno == EAGAIN) {
class xstransact:
def __init__(self, path):
- self.in_transaction = False
self.path = path.rstrip("/")
- xshandle().transaction_start()
+ self.transaction = xshandle().transaction_start()
self.in_transaction = True
def __del__(self):
if self.in_transaction:
- xshandle().transaction_end(True)
+ xshandle().transaction_end(self.transaction, True)
def commit(self):
if not self.in_transaction:
raise RuntimeError
self.in_transaction = False
- return xshandle().transaction_end(False)
+ rc = xshandle().transaction_end(self.transaction, False)
+ self.transaction = "0"
+ return rc
def abort(self):
+ if not self.in_transaction:
+ return True
self.in_transaction = False
- return xshandle().transaction_end(True)
+ rc = xshandle().transaction_end(self.transaction, True)
+ self.transaction = "0"
+ return rc
def _read(self, key):
path = "%s/%s" % (self.path, key)
try:
- return xshandle().read(path)
+ return xshandle().read(self.transaction, path)
except RuntimeError, ex:
raise RuntimeError(ex.args[0],
'%s, while reading %s' % (ex.args[1], path))
instead.
"""
if len(args) == 0:
- return xshandle().read(self.path)
+ return xshandle().read(self.transaction, self.path)
if len(args) == 1:
return self._read(args[0])
ret = []
def _write(self, key, data):
path = "%s/%s" % (self.path, key)
try:
- xshandle().write(path, data)
+ xshandle().write(self.transaction, path, data)
except RuntimeError, ex:
raise RuntimeError(ex.args[0],
('%s, while writing %s : %s' %
def _remove(self, key):
path = "%s/%s" % (self.path, key)
- return xshandle().rm(path)
+ return xshandle().rm(self.transaction, path)
def remove(self, *args):
"""If no arguments are given, remove this transaction's path.
path, and remove each of those instead.
"""
if len(args) == 0:
- xshandle().rm(self.path)
+ xshandle().rm(self.transaction, self.path)
else:
for key in args:
self._remove(key)
def _list(self, key):
path = "%s/%s" % (self.path, key)
- l = xshandle().ls(path)
+ l = xshandle().ls(self.transaction, path)
if l:
return map(lambda x: key + "/" + x, l)
return []
path, and return the cumulative listing of each of those instead.
"""
if len(args) == 0:
- ret = xshandle().ls(self.path)
+ ret = xshandle().ls(self.transaction, self.path)
if ret is None:
return []
else:
ret = []
for key in keys:
new_subdir = subdir + "/" + key
- l = xshandle().ls(new_subdir)
+ l = xshandle().ls(self.transaction, new_subdir)
if l:
ret.append([key, self.list_recursive_(new_subdir, l)])
else:
- ret.append([key, xshandle().read(new_subdir)])
+ ret.append([key, xshandle().read(self.transaction, new_subdir)])
return ret
INSTALL_DIR = $(INSTALL) -d -m0755
PROFILE=#-pg
-BASECFLAGS=-Wall -W -g -Werror
+BASECFLAGS=-Wall -g -Werror
# Make gcc generate dependencies.
BASECFLAGS += -Wp,-MD,.$(@F).d
PROG_DEP = .*.d
main(int argc, char **argv)
{
struct xs_handle *xsh;
+ struct xs_transaction_handle *xth;
bool success;
int ret = 0;
#if defined(CLIENT_read) || defined(CLIENT_list)
#endif
again:
- success = xs_transaction_start(xsh);
- if (!success)
+ xth = xs_transaction_start(xsh);
+ if (xth == NULL)
errx(1, "couldn't start transaction");
while (optind < argc) {
#if defined(CLIENT_read)
- char *val = xs_read(xsh, argv[optind], NULL);
+ char *val = xs_read(xsh, xth, argv[optind], NULL);
if (val == NULL) {
warnx("couldn't read path %s", argv[optind]);
ret = 1;
free(val);
optind++;
#elif defined(CLIENT_write)
- success = xs_write(xsh, argv[optind], argv[optind + 1],
+ success = xs_write(xsh, xth, argv[optind], argv[optind + 1],
strlen(argv[optind + 1]));
if (!success) {
warnx("could not write path %s", argv[optind]);
}
optind += 2;
#elif defined(CLIENT_rm)
- success = xs_rm(xsh, argv[optind]);
+ success = xs_rm(xsh, xth, argv[optind]);
if (!success) {
warnx("could not remove path %s", argv[optind]);
ret = 1;
}
optind++;
#elif defined(CLIENT_exists)
- char *val = xs_read(xsh, argv[optind], NULL);
+ char *val = xs_read(xsh, xth, argv[optind], NULL);
if (val == NULL) {
ret = 1;
goto out;
optind++;
#elif defined(CLIENT_list)
unsigned int i, num;
- char **list = xs_directory(xsh, argv[optind], &num);
+ char **list = xs_directory(xsh, xth, argv[optind], &num);
if (list == NULL) {
warnx("could not list path %s", argv[optind]);
ret = 1;
}
out:
- success = xs_transaction_end(xsh, ret ? true : false);
+ success = xs_transaction_end(xsh, xth, ret ? true : false);
if (!success) {
if (ret == 0 && errno == EAGAIN)
goto again;
pthread_t transaction_pthread;
};
+struct xs_transaction_handle {
+ int id;
+};
+
static void *read_thread(void *arg);
static void request_mutex_acquire(struct xs_handle *h)
return true;
}
-char **xs_directory(struct xs_handle *h, const char *path, unsigned int *num)
+char **xs_directory(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path, unsigned int *num)
{
char *strings, *p, **ret;
unsigned int len;
* Returns a malloced value: call free() on it after use.
* len indicates length in bytes, not including the nul.
*/
-void *xs_read(struct xs_handle *h, const char *path, unsigned int *len)
+void *xs_read(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path, unsigned int *len)
{
return xs_single(h, XS_READ, path, len);
}
/* Write the value of a single file.
* Returns false on failure.
*/
-bool xs_write(struct xs_handle *h, const char *path,
- const void *data, unsigned int len)
+bool xs_write(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path, const void *data, unsigned int len)
{
struct iovec iovec[2];
/* Create a new directory.
* Returns false on failure, or success if it already exists.
*/
-bool xs_mkdir(struct xs_handle *h, const char *path)
+bool xs_mkdir(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path)
{
return xs_bool(xs_single(h, XS_MKDIR, path, NULL));
}
/* Destroy a file or directory (directories must be empty).
* Returns false on failure, or success if it doesn't exist.
*/
-bool xs_rm(struct xs_handle *h, const char *path)
+bool xs_rm(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path)
{
return xs_bool(xs_single(h, XS_RM, path, NULL));
}
* Returns malloced array, or NULL: call free() after use.
*/
struct xs_permissions *xs_get_permissions(struct xs_handle *h,
+ struct xs_transaction_handle *t,
const char *path, unsigned int *num)
{
char *strings;
/* Set permissions of node (must be owner).
* Returns false on failure.
*/
-bool xs_set_permissions(struct xs_handle *h, const char *path,
+bool xs_set_permissions(struct xs_handle *h,
+ struct xs_transaction_handle *t,
+ const char *path,
struct xs_permissions *perms,
unsigned int num_perms)
{
/* Start a transaction: changes by others will not be seen during this
* transaction, and changes will not be visible to others until end.
* You can only have one transaction at any time.
- * Returns false on failure.
+ * Returns NULL on failure.
*/
-bool xs_transaction_start(struct xs_handle *h)
+struct xs_transaction_handle *xs_transaction_start(struct xs_handle *h)
{
bool rc;
pthread_mutex_unlock(&h->transaction_mutex);
}
- return rc;
+ return (struct xs_transaction_handle *)rc;
}
/* End a transaction.
* Returns false on failure, which indicates an error: transactions will
* not fail spuriously.
*/
-bool xs_transaction_end(struct xs_handle *h, bool abort)
+bool xs_transaction_end(struct xs_handle *h, struct xs_transaction_handle *t,
+ bool abort)
{
char abortstr[2];
bool rc;
+ if (t == NULL)
+ return -EINVAL;
+
if (abort)
strcpy(abortstr, "F");
else
#include <xs_lib.h>
struct xs_handle;
+struct xs_transaction_handle;
/* On failure, these routines set errno. */
* Returns a malloced array: call free() on it after use.
* Num indicates size.
*/
-char **xs_directory(struct xs_handle *h, const char *path, unsigned int *num);
+char **xs_directory(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path, unsigned int *num);
/* Get the value of a single file, nul terminated.
* Returns a malloced value: call free() on it after use.
* len indicates length in bytes, not including terminator.
*/
-void *xs_read(struct xs_handle *h, const char *path, unsigned int *len);
+void *xs_read(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path, unsigned int *len);
/* Write the value of a single file.
* Returns false on failure.
*/
-bool xs_write(struct xs_handle *h, const char *path, const void *data,
- unsigned int len);
+bool xs_write(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path, const void *data, unsigned int len);
/* Create a new directory.
* Returns false on failure, or success if it already exists.
*/
-bool xs_mkdir(struct xs_handle *h, const char *path);
+bool xs_mkdir(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path);
/* Destroy a file or directory (and children).
* Returns false on failure, or success if it doesn't exist.
*/
-bool xs_rm(struct xs_handle *h, const char *path);
+bool xs_rm(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path);
/* Get permissions of node (first element is owner, first perms is "other").
* Returns malloced array, or NULL: call free() after use.
*/
struct xs_permissions *xs_get_permissions(struct xs_handle *h,
+ struct xs_transaction_handle *t,
const char *path, unsigned int *num);
/* Set permissions of node (must be owner).
* Returns false on failure.
*/
-bool xs_set_permissions(struct xs_handle *h, const char *path,
- struct xs_permissions *perms, unsigned int num_perms);
+bool xs_set_permissions(struct xs_handle *h, struct xs_transaction_handle *t,
+ const char *path, struct xs_permissions *perms,
+ unsigned int num_perms);
/* Watch a node for changes (poll on fd to detect, or call read_watch()).
* When the node (or any child) changes, fd will become readable.
/* Start a transaction: changes by others will not be seen during this
* transaction, and changes will not be visible to others until end.
* You can only have one transaction at any time.
- * Returns false on failure.
+ * Returns NULL on failure.
*/
-bool xs_transaction_start(struct xs_handle *h);
+struct xs_transaction_handle *xs_transaction_start(struct xs_handle *h);
/* End a transaction.
* If abandon is true, transaction is discarded instead of committed.
* Returns false on failure: if errno == EAGAIN, you have to restart
* transaction.
*/
-bool xs_transaction_end(struct xs_handle *h, bool abort);
+bool xs_transaction_end(struct xs_handle *h, struct xs_transaction_handle *t,
+ bool abort);
/* Introduce a new domain.
* This tells the store daemon about a shared memory page, event channel
void *data, unsigned int len);
#endif /* _XS_H */
+
+/*
+ * Local variables:
+ * c-file-style: "linux"
+ * indent-tabs-mode: t
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * tab-width: 8
+ * End:
+ */
#define XSTEST
static struct xs_handle *handles[10] = { NULL };
+static struct xs_transaction_handle *txh[10] = { NULL };
static unsigned int timeout_ms = 500;
static bool timeout_suppressed = true;
char **entries;
unsigned int i, num;
- entries = xs_directory(handles[handle], path, &num);
+ entries = xs_directory(handles[handle], txh[handle], path, &num);
if (!entries) {
failed(handle);
return;
char *value;
unsigned int len;
- value = xs_read(handles[handle], path, &len);
+ value = xs_read(handles[handle], txh[handle], path, &len);
if (!value) {
failed(handle);
return;
static void do_write(unsigned int handle, char *path, char *data)
{
- if (!xs_write(handles[handle], path, data, strlen(data)))
+ if (!xs_write(handles[handle], txh[handle], path, data, strlen(data)))
failed(handle);
}
static void do_mkdir(unsigned int handle, char *path)
{
- if (!xs_mkdir(handles[handle], path))
+ if (!xs_mkdir(handles[handle], txh[handle], path))
failed(handle);
}
static void do_rm(unsigned int handle, char *path)
{
- if (!xs_rm(handles[handle], path))
+ if (!xs_rm(handles[handle], txh[handle], path))
failed(handle);
}
unsigned int i, num;
struct xs_permissions *perms;
- perms = xs_get_permissions(handles[handle], path, &num);
+ perms = xs_get_permissions(handles[handle], txh[handle], path, &num);
if (!perms) {
failed(handle);
return;
barf("bad flags %s\n", arg);
}
- if (!xs_set_permissions(handles[handle], path, perms, i))
+ if (!xs_set_permissions(handles[handle], txh[handle], path, perms, i))
failed(handle);
}
static void do_start(unsigned int handle)
{
- if (!xs_transaction_start(handles[handle]))
+ txh[handle] = xs_transaction_start(handles[handle]);
+ if (txh[handle] == NULL)
failed(handle);
}
static void do_end(unsigned int handle, bool abort)
{
- if (!xs_transaction_end(handles[handle], abort))
+ if (!xs_transaction_end(handles[handle], txh[handle], abort))
failed(handle);
+ txh[handle] = NULL;
}
static void do_introduce(unsigned int handle,
sprintf(subnode, "%s/%s", node, dir[i]);
- perms = xs_get_permissions(handles[handle], subnode,&numperms);
+ perms = xs_get_permissions(handles[handle], txh[handle],
+ subnode,&numperms);
if (!perms) {
failed(handle);
return;
output("\n");
/* Even directories can have contents. */
- contents = xs_read(handles[handle], subnode, &len);
+ contents = xs_read(handles[handle], txh[handle],
+ subnode, &len);
if (!contents) {
if (errno != EISDIR)
failed(handle);
}
/* Every node is a directory. */
- subdirs = xs_directory(handles[handle], subnode, &subnum);
+ subdirs = xs_directory(handles[handle], txh[handle],
+ subnode, &subnum);
if (!subdirs) {
failed(handle);
return;
char **subdirs;
unsigned int subnum;
- subdirs = xs_directory(handles[handle], "/", &subnum);
+ subdirs = xs_directory(handles[handle], txh[handle], "/", &subnum);
if (!subdirs) {
failed(handle);
return;
else if (streq(command, "close")) {
xs_daemon_close(handles[handle]);
handles[handle] = NULL;
+ txh[handle] = NULL;
} else if (streq(command, "start"))
do_start(handle);
else if (streq(command, "commit"))
return 0;
}
+
+/*
+ * Local variables:
+ * c-file-style: "linux"
+ * indent-tabs-mode: t
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * tab-width: 8
+ * End:
+ */
projects / xen.git / commitdiff